/**
 * 请求队列管理器
 * 用于控制并发请求数量，避免服务器压力过大
 */

class RequestQueue {
  constructor(options = {}) {
    this.maxConcurrent = options.maxConcurrent || 3  // 最大并发数（提升到3）
    this.minInterval = options.minInterval || 200     // 最小请求间隔(ms)（降到200ms）
    this.queue = []                                   // 请求队列
    this.running = []                                 // 正在执行的请求
    this.completed = 0                                // 已完成数量
    this.total = 0                                    // 总数量
    this.progressCallbacks = []                       // 进度回调
    this.lastRequestTime = 0                          // 上次请求时间
    this.currentTasks = []                            // 当前正在执行的任务名称
  }

  /**
   * 添加请求到队列
   * @param {Function} requestFn - 返回Promise的请求函数
   * @param {Object} options - 请求选项
   * @returns {Promise}
   */
  add(requestFn, options = {}) {
    return new Promise((resolve, reject) => {
      const task = {
        requestFn,
        resolve,
        reject,
        priority: options.priority || 0,  // 优先级，数字越大越优先
        name: options.name || 'Unknown'   // 请求名称，用于调试
      }
      
      this.queue.push(task)
      this.total++
      this.notifyProgress()
      this.processQueue()
    })
  }

  /**
   * 处理队列
   */
  async processQueue() {
    // 如果达到最大并发数，或队列为空，则不处理
    if (this.running.length >= this.maxConcurrent || this.queue.length === 0) {
      return
    }

    // 检查请求间隔
    const now = Date.now()
    const timeSinceLastRequest = now - this.lastRequestTime
    if (timeSinceLastRequest < this.minInterval && this.lastRequestTime > 0) {
      // 延迟执行
      setTimeout(() => this.processQueue(), this.minInterval - timeSinceLastRequest)
      return
    }

    // 按优先级排序（优先级高的先执行）
    this.queue.sort((a, b) => b.priority - a.priority)

    // 取出队列第一个任务
    const task = this.queue.shift()
    if (!task) return

    this.running.push(task)
    this.currentTasks.push(task.name)
    this.lastRequestTime = Date.now()

    console.log(`[RequestQueue] 开始请求: ${task.name}, 队列剩余: ${this.queue.length}, 并发数: ${this.running.length}`)
    
    // 通知进度更新（包含当前任务）
    this.notifyProgress()

    try {
      const result = await task.requestFn()
      task.resolve(result)
    } catch (error) {
      console.error(`[RequestQueue] 请求失败: ${task.name}`, error)
      task.reject(error)
    } finally {
      // 从运行队列中移除
      const index = this.running.indexOf(task)
      if (index > -1) {
        this.running.splice(index, 1)
      }
      
      // 从当前任务列表中移除
      const taskIndex = this.currentTasks.indexOf(task.name)
      if (taskIndex > -1) {
        this.currentTasks.splice(taskIndex, 1)
      }

      this.completed++
      this.notifyProgress()

      console.log(`[RequestQueue] 完成请求: ${task.name}, 进度: ${this.completed}/${this.total}`)

      // 继续处理队列
      this.processQueue()
    }
  }

  /**
   * 注册进度回调
   * @param {Function} callback - 回调函数 (completed, total, percent)
   */
  onProgress(callback) {
    if (typeof callback === 'function') {
      this.progressCallbacks.push(callback)
    }
  }

  /**
   * 通知进度更新
   */
  notifyProgress() {
    const percent = this.total > 0 ? Math.round((this.completed / this.total) * 100) : 0
    this.progressCallbacks.forEach(callback => {
      try {
        callback(this.completed, this.total, percent, this.currentTasks)
      } catch (error) {
        console.error('[RequestQueue] 进度回调错误:', error)
      }
    })
  }

  /**
   * 重置队列
   */
  reset() {
    this.queue = []
    this.running = []
    this.completed = 0
    this.total = 0
    this.currentTasks = []
    this.notifyProgress()
  }

  /**
   * 获取当前状态
   */
  getStatus() {
    return {
      queued: this.queue.length,
      running: this.running.length,
      completed: this.completed,
      total: this.total,
      percent: this.total > 0 ? Math.round((this.completed / this.total) * 100) : 0,
      currentTasks: this.currentTasks
    }
  }
}

// 创建全局单例
const globalQueue = new RequestQueue({
  maxConcurrent: 3,    // 最多同时3个请求（提升性能）
  minInterval: 200     // 每个请求间隔至少200ms（提升速度）
})

export default globalQueue
export { RequestQueue }

